Most consultancies wouldn't. Faster delivery at the same rate means more margin. But we'd rather align incentives from day one than have clients wondering whether we're padding timelines.
Let us explain what's actually happening - and where we're still figuring things out.
What "agentic development" actually means
Strip away the hype and here's what's left: senior engineers who know what they're doing, working with known secure architectures and world-class pipelines, using AI as a force multiplier rather than a replacement.
This isn't about replacing developers with chatbots. It's about what happens when a senior architect with 15 years of pattern recognition can move at the speed of their thinking instead of the speed of their typing. The bottleneck was never intelligence. It was throughput.
The quality bar doesn't change. The same experienced engineers, the same architectural standards, the same code review processes. What changes is how much elapsed time it takes to get there.
What this looks like in practice
Last week a client came to us after working with another firm for 12 weeks. They'd received a 65-page discovery document and a 20-week timeline. No working software. No market validation. Just documentation. The firm was proud of their "agile delivery method" but required a change order if anything varied from the discovery document. That's not agile. That's waterfall wearing a costume.
We got carried away and spent a day building the app. Take pictures, attach voice notes, transcribe them, generate AI evaluation, publish to PDF. Not polished, but working. Enough to test assumptions before building the wrong thing.
They were planning to launch in June. We'll have them in market in January.
That's not a miracle. That's what happens when you stop treating AI as a threat or a toy and start treating it as infrastructure. The capability exists. The question is whether your team is structured to use it.
Why we price the speed honestly
We could argue that faster delivery at traditional rates is pure value for clients. Ship in two weeks instead of six, pay the same amount, everybody wins. Technically true.
But the traditional consulting model is built on opacity. Bill hours, extend timelines, create dependency. The longer something takes, the more the consultancy makes. That's a structure that rewards the wrong behavior.
We've been building software for 12 years. We've seen what happens when the incentives are misaligned - projects that drag, relationships that sour, software that ships late and breaks early. We’re trying to build something different. Maybe that's naive. But we'd rather find out by trying than by assuming it can't work.
So we price the speed honestly. Clients get a better deal. We get a sustainable margin on faster turns. And nobody's playing games about whether the timeline is real.
Working software creates truth. So does honest pricing.
Where this doesn't work (yet)
We want to be clear about the boundaries.
Agentic development works best when you have clarity on what you're building and why. A greenfield build with a modern stack, a clear MVP, a team that can make decisions quickly. That's where the speed advantage is enormous.
It works less well when the problem is still fuzzy. If you need extensive discovery to figure out what you're even building, the AI acceleration doesn't help as much - the bottleneck is clarity, not throughput.
It's harder to apply to legacy modernization with significant constraints. When you're navigating decade-old systems, compliance requirements, and organizational politics, the limiting factor isn't how fast you can write code.
We're still learning where the edges are. Every project teaches us something about where this approach shines and where it struggles. That's part of why we're building internal tools with it too - we want to hit the walls ourselves before clients do.
The window
Here's what we think most people miss: this advantage is temporary.
Right now, the gap between teams using agentic development and teams doing things the traditional way is significant. But that gap will close. Larger consultancies will figure this out. The tooling will commoditize. In 12-18 months, agentic development won't be a differentiator. It'll be table stakes.
The question for companies building software right now isn't whether to adopt these approaches. It's whether to move now, while the speed advantage is significant, or wait until everyone's caught up and the window has closed.
We’re betting on now. The honest pricing is my way of making that bet alongside clients who want to move.
If this sounds like your situation
If you're evaluating a build - especially a greenfield product, a platform migration, or something that needs to be in market fast - this might be worth a conversation.
We’re not trying to sell agentic development to everyone. We’re trying to find the projects where it's the right fit and deliver something that makes both of us look good.